// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.tmp.walmart.item;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.TmpWalmartItem;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(TmpWalmartItem.class)
@Setter
@Getter
public class TmpWalmartItemSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "TmpWalmartItem".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 最小店铺
   */
  private Long sidMin;

  /**
   * 最大店铺
   */
  private Long sidMax;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * SKU(模糊搜索)
   */
  private String localSku;

  /**
   * SKU 比较(eq)
   */
  private String localSkuEq;
  /**
   * SKU 比较(neq)
   */
  private String localSkuNeq;
  /**
   * SKU 比较(gt)
   */
  private String localSkuGt;
  /**
   * SKU 比较(gte)
   */
  private String localSkuGte;
  /**
   * SKU 比较(lt)
   */
  private String localSkuLt;
  /**
   * SKU 比较(lte)
   */
  private String localSkuLte;
  /**
   * SKU 比较(contains)
   */
  private String localSkuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String localSkuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String localSkuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String localSkuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean localSkuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean localSkuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> localSkuInList;

  /**
   * 品名(模糊搜索)
   */
  private String localName;

  /**
   * 品名 比较(eq)
   */
  private String localNameEq;
  /**
   * 品名 比较(neq)
   */
  private String localNameNeq;
  /**
   * 品名 比较(gt)
   */
  private String localNameGt;
  /**
   * 品名 比较(gte)
   */
  private String localNameGte;
  /**
   * 品名 比较(lt)
   */
  private String localNameLt;
  /**
   * 品名 比较(lte)
   */
  private String localNameLte;
  /**
   * 品名 比较(contains)
   */
  private String localNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private String localNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private String localNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private String localNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean localNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean localNameIsnotnull;

  /**
   * 品名(精确搜索)
   */
  private List<String> localNameInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * 商品ID(模糊搜索)
   */
  private String itemId;

  /**
   * 商品ID 比较(eq)
   */
  private String itemIdEq;
  /**
   * 商品ID 比较(neq)
   */
  private String itemIdNeq;
  /**
   * 商品ID 比较(gt)
   */
  private String itemIdGt;
  /**
   * 商品ID 比较(gte)
   */
  private String itemIdGte;
  /**
   * 商品ID 比较(lt)
   */
  private String itemIdLt;
  /**
   * 商品ID 比较(lte)
   */
  private String itemIdLte;
  /**
   * 商品ID 比较(contains)
   */
  private String itemIdContains;
  /**
   * 商品ID 比较(notcontains)
   */
  private String itemIdNotcontains;
  /**
   * 商品ID 比较(startswith)
   */
  private String itemIdStartswith;
  /**
   * 商品ID 比较(endswith)
   */
  private String itemIdEndswith;
  /**
   * 商品ID 比较(isnull)
   */
  private Boolean itemIdIsnull;
  /**
   * 商品ID 比较(isnotnull)
   */
  private Boolean itemIdIsnotnull;

  /**
   * 商品ID(精确搜索)
   */
  private List<String> itemIdInList;

  /**
   * 标题(模糊搜索)
   */
  private String title;

  /**
   * 标题 比较(eq)
   */
  private String titleEq;
  /**
   * 标题 比较(neq)
   */
  private String titleNeq;
  /**
   * 标题 比较(gt)
   */
  private String titleGt;
  /**
   * 标题 比较(gte)
   */
  private String titleGte;
  /**
   * 标题 比较(lt)
   */
  private String titleLt;
  /**
   * 标题 比较(lte)
   */
  private String titleLte;
  /**
   * 标题 比较(contains)
   */
  private String titleContains;
  /**
   * 标题 比较(notcontains)
   */
  private String titleNotcontains;
  /**
   * 标题 比较(startswith)
   */
  private String titleStartswith;
  /**
   * 标题 比较(endswith)
   */
  private String titleEndswith;
  /**
   * 标题 比较(isnull)
   */
  private Boolean titleIsnull;
  /**
   * 标题 比较(isnotnull)
   */
  private Boolean titleIsnotnull;

  /**
   * 标题(精确搜索)
   */
  private List<String> titleInList;

  /**
   * 生命周期状态(模糊搜索)
   */
  private String lifecycleStatus;

  /**
   * 生命周期状态 比较(eq)
   */
  private String lifecycleStatusEq;
  /**
   * 生命周期状态 比较(neq)
   */
  private String lifecycleStatusNeq;
  /**
   * 生命周期状态 比较(gt)
   */
  private String lifecycleStatusGt;
  /**
   * 生命周期状态 比较(gte)
   */
  private String lifecycleStatusGte;
  /**
   * 生命周期状态 比较(lt)
   */
  private String lifecycleStatusLt;
  /**
   * 生命周期状态 比较(lte)
   */
  private String lifecycleStatusLte;
  /**
   * 生命周期状态 比较(contains)
   */
  private String lifecycleStatusContains;
  /**
   * 生命周期状态 比较(notcontains)
   */
  private String lifecycleStatusNotcontains;
  /**
   * 生命周期状态 比较(startswith)
   */
  private String lifecycleStatusStartswith;
  /**
   * 生命周期状态 比较(endswith)
   */
  private String lifecycleStatusEndswith;
  /**
   * 生命周期状态 比较(isnull)
   */
  private Boolean lifecycleStatusIsnull;
  /**
   * 生命周期状态 比较(isnotnull)
   */
  private Boolean lifecycleStatusIsnotnull;

  /**
   * 生命周期状态(精确搜索)
   */
  private List<String> lifecycleStatusInList;

  /**
   * 发布状态(模糊搜索)
   */
  private String publishedStatus;

  /**
   * 发布状态 比较(eq)
   */
  private String publishedStatusEq;
  /**
   * 发布状态 比较(neq)
   */
  private String publishedStatusNeq;
  /**
   * 发布状态 比较(gt)
   */
  private String publishedStatusGt;
  /**
   * 发布状态 比较(gte)
   */
  private String publishedStatusGte;
  /**
   * 发布状态 比较(lt)
   */
  private String publishedStatusLt;
  /**
   * 发布状态 比较(lte)
   */
  private String publishedStatusLte;
  /**
   * 发布状态 比较(contains)
   */
  private String publishedStatusContains;
  /**
   * 发布状态 比较(notcontains)
   */
  private String publishedStatusNotcontains;
  /**
   * 发布状态 比较(startswith)
   */
  private String publishedStatusStartswith;
  /**
   * 发布状态 比较(endswith)
   */
  private String publishedStatusEndswith;
  /**
   * 发布状态 比较(isnull)
   */
  private Boolean publishedStatusIsnull;
  /**
   * 发布状态 比较(isnotnull)
   */
  private Boolean publishedStatusIsnotnull;

  /**
   * 发布状态(精确搜索)
   */
  private List<String> publishedStatusInList;

  /**
   * 状态变化的原因(模糊搜索)
   */
  private String statusChangeReason;

  /**
   * 状态变化的原因 比较(eq)
   */
  private String statusChangeReasonEq;
  /**
   * 状态变化的原因 比较(neq)
   */
  private String statusChangeReasonNeq;
  /**
   * 状态变化的原因 比较(gt)
   */
  private String statusChangeReasonGt;
  /**
   * 状态变化的原因 比较(gte)
   */
  private String statusChangeReasonGte;
  /**
   * 状态变化的原因 比较(lt)
   */
  private String statusChangeReasonLt;
  /**
   * 状态变化的原因 比较(lte)
   */
  private String statusChangeReasonLte;
  /**
   * 状态变化的原因 比较(contains)
   */
  private String statusChangeReasonContains;
  /**
   * 状态变化的原因 比较(notcontains)
   */
  private String statusChangeReasonNotcontains;
  /**
   * 状态变化的原因 比较(startswith)
   */
  private String statusChangeReasonStartswith;
  /**
   * 状态变化的原因 比较(endswith)
   */
  private String statusChangeReasonEndswith;
  /**
   * 状态变化的原因 比较(isnull)
   */
  private Boolean statusChangeReasonIsnull;
  /**
   * 状态变化的原因 比较(isnotnull)
   */
  private Boolean statusChangeReasonIsnotnull;

  /**
   * 商品类别(模糊搜索)
   */
  private String productCategory;

  /**
   * 商品类别 比较(eq)
   */
  private String productCategoryEq;
  /**
   * 商品类别 比较(neq)
   */
  private String productCategoryNeq;
  /**
   * 商品类别 比较(gt)
   */
  private String productCategoryGt;
  /**
   * 商品类别 比较(gte)
   */
  private String productCategoryGte;
  /**
   * 商品类别 比较(lt)
   */
  private String productCategoryLt;
  /**
   * 商品类别 比较(lte)
   */
  private String productCategoryLte;
  /**
   * 商品类别 比较(contains)
   */
  private String productCategoryContains;
  /**
   * 商品类别 比较(notcontains)
   */
  private String productCategoryNotcontains;
  /**
   * 商品类别 比较(startswith)
   */
  private String productCategoryStartswith;
  /**
   * 商品类别 比较(endswith)
   */
  private String productCategoryEndswith;
  /**
   * 商品类别 比较(isnull)
   */
  private Boolean productCategoryIsnull;
  /**
   * 商品类别 比较(isnotnull)
   */
  private Boolean productCategoryIsnotnull;

  /**
   * 商品类别(精确搜索)
   */
  private List<String> productCategoryInList;

  /**
   * 价格
   */
  private java.math.BigDecimal priceAmount;

  /**
   * 最小价格
   */
  private java.math.BigDecimal priceAmountMin;

  /**
   * 最大价格
   */
  private java.math.BigDecimal priceAmountMax;

  /**
   * 价格 比较(eq)
   */
  private java.math.BigDecimal priceAmountEq;
  /**
   * 价格 比较(neq)
   */
  private java.math.BigDecimal priceAmountNeq;
  /**
   * 价格 比较(gt)
   */
  private java.math.BigDecimal priceAmountGt;
  /**
   * 价格 比较(gte)
   */
  private java.math.BigDecimal priceAmountGte;
  /**
   * 价格 比较(lt)
   */
  private java.math.BigDecimal priceAmountLt;
  /**
   * 价格 比较(lte)
   */
  private java.math.BigDecimal priceAmountLte;
  /**
   * 价格 比较(contains)
   */
  private java.math.BigDecimal priceAmountContains;
  /**
   * 价格 比较(notcontains)
   */
  private java.math.BigDecimal priceAmountNotcontains;
  /**
   * 价格 比较(startswith)
   */
  private java.math.BigDecimal priceAmountStartswith;
  /**
   * 价格 比较(endswith)
   */
  private java.math.BigDecimal priceAmountEndswith;
  /**
   * 价格 比较(isnull)
   */
  private Boolean priceAmountIsnull;
  /**
   * 价格 比较(isnotnull)
   */
  private Boolean priceAmountIsnotnull;

  /**
   * 价格币种(模糊搜索)
   */
  private String priceCurrency;

  /**
   * 价格币种 比较(eq)
   */
  private String priceCurrencyEq;
  /**
   * 价格币种 比较(neq)
   */
  private String priceCurrencyNeq;
  /**
   * 价格币种 比较(gt)
   */
  private String priceCurrencyGt;
  /**
   * 价格币种 比较(gte)
   */
  private String priceCurrencyGte;
  /**
   * 价格币种 比较(lt)
   */
  private String priceCurrencyLt;
  /**
   * 价格币种 比较(lte)
   */
  private String priceCurrencyLte;
  /**
   * 价格币种 比较(contains)
   */
  private String priceCurrencyContains;
  /**
   * 价格币种 比较(notcontains)
   */
  private String priceCurrencyNotcontains;
  /**
   * 价格币种 比较(startswith)
   */
  private String priceCurrencyStartswith;
  /**
   * 价格币种 比较(endswith)
   */
  private String priceCurrencyEndswith;
  /**
   * 价格币种 比较(isnull)
   */
  private Boolean priceCurrencyIsnull;
  /**
   * 价格币种 比较(isnotnull)
   */
  private Boolean priceCurrencyIsnotnull;

  /**
   * 价格币种(精确搜索)
   */
  private List<String> priceCurrencyInList;

  /**
   * Buy Box 价格
   */
  private java.math.BigDecimal buyBoxItemPrice;

  /**
   * 最小Buy Box 价格
   */
  private java.math.BigDecimal buyBoxItemPriceMin;

  /**
   * 最大Buy Box 价格
   */
  private java.math.BigDecimal buyBoxItemPriceMax;

  /**
   * Buy Box 价格 比较(eq)
   */
  private java.math.BigDecimal buyBoxItemPriceEq;
  /**
   * Buy Box 价格 比较(neq)
   */
  private java.math.BigDecimal buyBoxItemPriceNeq;
  /**
   * Buy Box 价格 比较(gt)
   */
  private java.math.BigDecimal buyBoxItemPriceGt;
  /**
   * Buy Box 价格 比较(gte)
   */
  private java.math.BigDecimal buyBoxItemPriceGte;
  /**
   * Buy Box 价格 比较(lt)
   */
  private java.math.BigDecimal buyBoxItemPriceLt;
  /**
   * Buy Box 价格 比较(lte)
   */
  private java.math.BigDecimal buyBoxItemPriceLte;
  /**
   * Buy Box 价格 比较(contains)
   */
  private java.math.BigDecimal buyBoxItemPriceContains;
  /**
   * Buy Box 价格 比较(notcontains)
   */
  private java.math.BigDecimal buyBoxItemPriceNotcontains;
  /**
   * Buy Box 价格 比较(startswith)
   */
  private java.math.BigDecimal buyBoxItemPriceStartswith;
  /**
   * Buy Box 价格 比较(endswith)
   */
  private java.math.BigDecimal buyBoxItemPriceEndswith;
  /**
   * Buy Box 价格 比较(isnull)
   */
  private Boolean buyBoxItemPriceIsnull;
  /**
   * Buy Box 价格 比较(isnotnull)
   */
  private Boolean buyBoxItemPriceIsnotnull;

  /**
   * Buy Box 运费
   */
  private java.math.BigDecimal buyBoxShippingPrice;

  /**
   * 最小Buy Box 运费
   */
  private java.math.BigDecimal buyBoxShippingPriceMin;

  /**
   * 最大Buy Box 运费
   */
  private java.math.BigDecimal buyBoxShippingPriceMax;

  /**
   * Buy Box 运费 比较(eq)
   */
  private java.math.BigDecimal buyBoxShippingPriceEq;
  /**
   * Buy Box 运费 比较(neq)
   */
  private java.math.BigDecimal buyBoxShippingPriceNeq;
  /**
   * Buy Box 运费 比较(gt)
   */
  private java.math.BigDecimal buyBoxShippingPriceGt;
  /**
   * Buy Box 运费 比较(gte)
   */
  private java.math.BigDecimal buyBoxShippingPriceGte;
  /**
   * Buy Box 运费 比较(lt)
   */
  private java.math.BigDecimal buyBoxShippingPriceLt;
  /**
   * Buy Box 运费 比较(lte)
   */
  private java.math.BigDecimal buyBoxShippingPriceLte;
  /**
   * Buy Box 运费 比较(contains)
   */
  private java.math.BigDecimal buyBoxShippingPriceContains;
  /**
   * Buy Box 运费 比较(notcontains)
   */
  private java.math.BigDecimal buyBoxShippingPriceNotcontains;
  /**
   * Buy Box 运费 比较(startswith)
   */
  private java.math.BigDecimal buyBoxShippingPriceStartswith;
  /**
   * Buy Box 运费 比较(endswith)
   */
  private java.math.BigDecimal buyBoxShippingPriceEndswith;
  /**
   * Buy Box 运费 比较(isnull)
   */
  private Boolean buyBoxShippingPriceIsnull;
  /**
   * Buy Box 运费 比较(isnotnull)
   */
  private Boolean buyBoxShippingPriceIsnotnull;

  /**
   * 是否Buy Box(模糊搜索)
   */
  private String buyBoxEligible;

  /**
   * 是否Buy Box 比较(eq)
   */
  private String buyBoxEligibleEq;
  /**
   * 是否Buy Box 比较(neq)
   */
  private String buyBoxEligibleNeq;
  /**
   * 是否Buy Box 比较(gt)
   */
  private String buyBoxEligibleGt;
  /**
   * 是否Buy Box 比较(gte)
   */
  private String buyBoxEligibleGte;
  /**
   * 是否Buy Box 比较(lt)
   */
  private String buyBoxEligibleLt;
  /**
   * 是否Buy Box 比较(lte)
   */
  private String buyBoxEligibleLte;
  /**
   * 是否Buy Box 比较(contains)
   */
  private String buyBoxEligibleContains;
  /**
   * 是否Buy Box 比较(notcontains)
   */
  private String buyBoxEligibleNotcontains;
  /**
   * 是否Buy Box 比较(startswith)
   */
  private String buyBoxEligibleStartswith;
  /**
   * 是否Buy Box 比较(endswith)
   */
  private String buyBoxEligibleEndswith;
  /**
   * 是否Buy Box 比较(isnull)
   */
  private Boolean buyBoxEligibleIsnull;
  /**
   * 是否Buy Box 比较(isnotnull)
   */
  private Boolean buyBoxEligibleIsnotnull;

  /**
   * 是否Buy Box(精确搜索)
   */
  private List<String> buyBoxEligibleInList;

  /**
   * MSRP(模糊搜索)
   */
  private String msrp;

  /**
   * MSRP 比较(eq)
   */
  private String msrpEq;
  /**
   * MSRP 比较(neq)
   */
  private String msrpNeq;
  /**
   * MSRP 比较(gt)
   */
  private String msrpGt;
  /**
   * MSRP 比较(gte)
   */
  private String msrpGte;
  /**
   * MSRP 比较(lt)
   */
  private String msrpLt;
  /**
   * MSRP 比较(lte)
   */
  private String msrpLte;
  /**
   * MSRP 比较(contains)
   */
  private String msrpContains;
  /**
   * MSRP 比较(notcontains)
   */
  private String msrpNotcontains;
  /**
   * MSRP 比较(startswith)
   */
  private String msrpStartswith;
  /**
   * MSRP 比较(endswith)
   */
  private String msrpEndswith;
  /**
   * MSRP 比较(isnull)
   */
  private Boolean msrpIsnull;
  /**
   * MSRP 比较(isnotnull)
   */
  private Boolean msrpIsnotnull;

  /**
   * MSRP(精确搜索)
   */
  private List<String> msrpInList;

  /**
   * 商品税号(模糊搜索)
   */
  private String productTaxCode;

  /**
   * 商品税号 比较(eq)
   */
  private String productTaxCodeEq;
  /**
   * 商品税号 比较(neq)
   */
  private String productTaxCodeNeq;
  /**
   * 商品税号 比较(gt)
   */
  private String productTaxCodeGt;
  /**
   * 商品税号 比较(gte)
   */
  private String productTaxCodeGte;
  /**
   * 商品税号 比较(lt)
   */
  private String productTaxCodeLt;
  /**
   * 商品税号 比较(lte)
   */
  private String productTaxCodeLte;
  /**
   * 商品税号 比较(contains)
   */
  private String productTaxCodeContains;
  /**
   * 商品税号 比较(notcontains)
   */
  private String productTaxCodeNotcontains;
  /**
   * 商品税号 比较(startswith)
   */
  private String productTaxCodeStartswith;
  /**
   * 商品税号 比较(endswith)
   */
  private String productTaxCodeEndswith;
  /**
   * 商品税号 比较(isnull)
   */
  private Boolean productTaxCodeIsnull;
  /**
   * 商品税号 比较(isnotnull)
   */
  private Boolean productTaxCodeIsnotnull;

  /**
   * 商品税号(精确搜索)
   */
  private List<String> productTaxCodeInList;

  /**
   * 运输方法(模糊搜索)
   */
  private String shipMethods;

  /**
   * 运输方法 比较(eq)
   */
  private String shipMethodsEq;
  /**
   * 运输方法 比较(neq)
   */
  private String shipMethodsNeq;
  /**
   * 运输方法 比较(gt)
   */
  private String shipMethodsGt;
  /**
   * 运输方法 比较(gte)
   */
  private String shipMethodsGte;
  /**
   * 运输方法 比较(lt)
   */
  private String shipMethodsLt;
  /**
   * 运输方法 比较(lte)
   */
  private String shipMethodsLte;
  /**
   * 运输方法 比较(contains)
   */
  private String shipMethodsContains;
  /**
   * 运输方法 比较(notcontains)
   */
  private String shipMethodsNotcontains;
  /**
   * 运输方法 比较(startswith)
   */
  private String shipMethodsStartswith;
  /**
   * 运输方法 比较(endswith)
   */
  private String shipMethodsEndswith;
  /**
   * 运输方法 比较(isnull)
   */
  private Boolean shipMethodsIsnull;
  /**
   * 运输方法 比较(isnotnull)
   */
  private Boolean shipMethodsIsnotnull;

  /**
   * 运输方法(精确搜索)
   */
  private List<String> shipMethodsInList;

  /**
   * 商品重量
   */
  private java.math.BigDecimal shippingWeight;

  /**
   * 最小商品重量
   */
  private java.math.BigDecimal shippingWeightMin;

  /**
   * 最大商品重量
   */
  private java.math.BigDecimal shippingWeightMax;

  /**
   * 商品重量 比较(eq)
   */
  private java.math.BigDecimal shippingWeightEq;
  /**
   * 商品重量 比较(neq)
   */
  private java.math.BigDecimal shippingWeightNeq;
  /**
   * 商品重量 比较(gt)
   */
  private java.math.BigDecimal shippingWeightGt;
  /**
   * 商品重量 比较(gte)
   */
  private java.math.BigDecimal shippingWeightGte;
  /**
   * 商品重量 比较(lt)
   */
  private java.math.BigDecimal shippingWeightLt;
  /**
   * 商品重量 比较(lte)
   */
  private java.math.BigDecimal shippingWeightLte;
  /**
   * 商品重量 比较(contains)
   */
  private java.math.BigDecimal shippingWeightContains;
  /**
   * 商品重量 比较(notcontains)
   */
  private java.math.BigDecimal shippingWeightNotcontains;
  /**
   * 商品重量 比较(startswith)
   */
  private java.math.BigDecimal shippingWeightStartswith;
  /**
   * 商品重量 比较(endswith)
   */
  private java.math.BigDecimal shippingWeightEndswith;
  /**
   * 商品重量 比较(isnull)
   */
  private Boolean shippingWeightIsnull;
  /**
   * 商品重量 比较(isnotnull)
   */
  private Boolean shippingWeightIsnotnull;

  /**
   * 重量单位(模糊搜索)
   */
  private String shippingWeightUnit;

  /**
   * 重量单位 比较(eq)
   */
  private String shippingWeightUnitEq;
  /**
   * 重量单位 比较(neq)
   */
  private String shippingWeightUnitNeq;
  /**
   * 重量单位 比较(gt)
   */
  private String shippingWeightUnitGt;
  /**
   * 重量单位 比较(gte)
   */
  private String shippingWeightUnitGte;
  /**
   * 重量单位 比较(lt)
   */
  private String shippingWeightUnitLt;
  /**
   * 重量单位 比较(lte)
   */
  private String shippingWeightUnitLte;
  /**
   * 重量单位 比较(contains)
   */
  private String shippingWeightUnitContains;
  /**
   * 重量单位 比较(notcontains)
   */
  private String shippingWeightUnitNotcontains;
  /**
   * 重量单位 比较(startswith)
   */
  private String shippingWeightUnitStartswith;
  /**
   * 重量单位 比较(endswith)
   */
  private String shippingWeightUnitEndswith;
  /**
   * 重量单位 比较(isnull)
   */
  private Boolean shippingWeightUnitIsnull;
  /**
   * 重量单位 比较(isnotnull)
   */
  private Boolean shippingWeightUnitIsnotnull;

  /**
   * 重量单位(精确搜索)
   */
  private List<String> shippingWeightUnitInList;

  /**
   * 发货时限
   */
  private Integer fulfillmentLagTime;

  /**
   * 最小发货时限
   */
  private Integer fulfillmentLagTimeMin;

  /**
   * 最大发货时限
   */
  private Integer fulfillmentLagTimeMax;

  /**
   * 发货时限 比较(eq)
   */
  private Integer fulfillmentLagTimeEq;
  /**
   * 发货时限 比较(neq)
   */
  private Integer fulfillmentLagTimeNeq;
  /**
   * 发货时限 比较(gt)
   */
  private Integer fulfillmentLagTimeGt;
  /**
   * 发货时限 比较(gte)
   */
  private Integer fulfillmentLagTimeGte;
  /**
   * 发货时限 比较(lt)
   */
  private Integer fulfillmentLagTimeLt;
  /**
   * 发货时限 比较(lte)
   */
  private Integer fulfillmentLagTimeLte;
  /**
   * 发货时限 比较(contains)
   */
  private Integer fulfillmentLagTimeContains;
  /**
   * 发货时限 比较(notcontains)
   */
  private Integer fulfillmentLagTimeNotcontains;
  /**
   * 发货时限 比较(startswith)
   */
  private Integer fulfillmentLagTimeStartswith;
  /**
   * 发货时限 比较(endswith)
   */
  private Integer fulfillmentLagTimeEndswith;
  /**
   * 发货时限 比较(isnull)
   */
  private Boolean fulfillmentLagTimeIsnull;
  /**
   * 发货时限 比较(isnotnull)
   */
  private Boolean fulfillmentLagTimeIsnotnull;

  /**
   * 发货方式(模糊搜索)
   */
  private String fulfillmentType;

  /**
   * 发货方式 比较(eq)
   */
  private String fulfillmentTypeEq;
  /**
   * 发货方式 比较(neq)
   */
  private String fulfillmentTypeNeq;
  /**
   * 发货方式 比较(gt)
   */
  private String fulfillmentTypeGt;
  /**
   * 发货方式 比较(gte)
   */
  private String fulfillmentTypeGte;
  /**
   * 发货方式 比较(lt)
   */
  private String fulfillmentTypeLt;
  /**
   * 发货方式 比较(lte)
   */
  private String fulfillmentTypeLte;
  /**
   * 发货方式 比较(contains)
   */
  private String fulfillmentTypeContains;
  /**
   * 发货方式 比较(notcontains)
   */
  private String fulfillmentTypeNotcontains;
  /**
   * 发货方式 比较(startswith)
   */
  private String fulfillmentTypeStartswith;
  /**
   * 发货方式 比较(endswith)
   */
  private String fulfillmentTypeEndswith;
  /**
   * 发货方式 比较(isnull)
   */
  private Boolean fulfillmentTypeIsnull;
  /**
   * 发货方式 比较(isnotnull)
   */
  private Boolean fulfillmentTypeIsnotnull;

  /**
   * 发货方式(精确搜索)
   */
  private List<String> fulfillmentTypeInList;

  /**
   * WFS销售限制(模糊搜索)
   */
  private String wfsSalesRestriction;

  /**
   * WFS销售限制 比较(eq)
   */
  private String wfsSalesRestrictionEq;
  /**
   * WFS销售限制 比较(neq)
   */
  private String wfsSalesRestrictionNeq;
  /**
   * WFS销售限制 比较(gt)
   */
  private String wfsSalesRestrictionGt;
  /**
   * WFS销售限制 比较(gte)
   */
  private String wfsSalesRestrictionGte;
  /**
   * WFS销售限制 比较(lt)
   */
  private String wfsSalesRestrictionLt;
  /**
   * WFS销售限制 比较(lte)
   */
  private String wfsSalesRestrictionLte;
  /**
   * WFS销售限制 比较(contains)
   */
  private String wfsSalesRestrictionContains;
  /**
   * WFS销售限制 比较(notcontains)
   */
  private String wfsSalesRestrictionNotcontains;
  /**
   * WFS销售限制 比较(startswith)
   */
  private String wfsSalesRestrictionStartswith;
  /**
   * WFS销售限制 比较(endswith)
   */
  private String wfsSalesRestrictionEndswith;
  /**
   * WFS销售限制 比较(isnull)
   */
  private Boolean wfsSalesRestrictionIsnull;
  /**
   * WFS销售限制 比较(isnotnull)
   */
  private Boolean wfsSalesRestrictionIsnotnull;

  /**
   * WFS销售限制(精确搜索)
   */
  private List<String> wfsSalesRestrictionInList;

  /**
   * 沃尔玛产品ID(模糊搜索)
   */
  private String wpid;

  /**
   * 沃尔玛产品ID 比较(eq)
   */
  private String wpidEq;
  /**
   * 沃尔玛产品ID 比较(neq)
   */
  private String wpidNeq;
  /**
   * 沃尔玛产品ID 比较(gt)
   */
  private String wpidGt;
  /**
   * 沃尔玛产品ID 比较(gte)
   */
  private String wpidGte;
  /**
   * 沃尔玛产品ID 比较(lt)
   */
  private String wpidLt;
  /**
   * 沃尔玛产品ID 比较(lte)
   */
  private String wpidLte;
  /**
   * 沃尔玛产品ID 比较(contains)
   */
  private String wpidContains;
  /**
   * 沃尔玛产品ID 比较(notcontains)
   */
  private String wpidNotcontains;
  /**
   * 沃尔玛产品ID 比较(startswith)
   */
  private String wpidStartswith;
  /**
   * 沃尔玛产品ID 比较(endswith)
   */
  private String wpidEndswith;
  /**
   * 沃尔玛产品ID 比较(isnull)
   */
  private Boolean wpidIsnull;
  /**
   * 沃尔玛产品ID 比较(isnotnull)
   */
  private Boolean wpidIsnotnull;

  /**
   * 沃尔玛产品ID(精确搜索)
   */
  private List<String> wpidInList;

  /**
   * GTIN(模糊搜索)
   */
  private String gtin;

  /**
   * GTIN 比较(eq)
   */
  private String gtinEq;
  /**
   * GTIN 比较(neq)
   */
  private String gtinNeq;
  /**
   * GTIN 比较(gt)
   */
  private String gtinGt;
  /**
   * GTIN 比较(gte)
   */
  private String gtinGte;
  /**
   * GTIN 比较(lt)
   */
  private String gtinLt;
  /**
   * GTIN 比较(lte)
   */
  private String gtinLte;
  /**
   * GTIN 比较(contains)
   */
  private String gtinContains;
  /**
   * GTIN 比较(notcontains)
   */
  private String gtinNotcontains;
  /**
   * GTIN 比较(startswith)
   */
  private String gtinStartswith;
  /**
   * GTIN 比较(endswith)
   */
  private String gtinEndswith;
  /**
   * GTIN 比较(isnull)
   */
  private Boolean gtinIsnull;
  /**
   * GTIN 比较(isnotnull)
   */
  private Boolean gtinIsnotnull;

  /**
   * GTIN(精确搜索)
   */
  private List<String> gtinInList;

  /**
   * UPC(模糊搜索)
   */
  private String upc;

  /**
   * UPC 比较(eq)
   */
  private String upcEq;
  /**
   * UPC 比较(neq)
   */
  private String upcNeq;
  /**
   * UPC 比较(gt)
   */
  private String upcGt;
  /**
   * UPC 比较(gte)
   */
  private String upcGte;
  /**
   * UPC 比较(lt)
   */
  private String upcLt;
  /**
   * UPC 比较(lte)
   */
  private String upcLte;
  /**
   * UPC 比较(contains)
   */
  private String upcContains;
  /**
   * UPC 比较(notcontains)
   */
  private String upcNotcontains;
  /**
   * UPC 比较(startswith)
   */
  private String upcStartswith;
  /**
   * UPC 比较(endswith)
   */
  private String upcEndswith;
  /**
   * UPC 比较(isnull)
   */
  private Boolean upcIsnull;
  /**
   * UPC 比较(isnotnull)
   */
  private Boolean upcIsnotnull;

  /**
   * UPC(精确搜索)
   */
  private List<String> upcInList;

  /**
   * 商品页面地址(模糊搜索)
   */
  private String itemPageUrl;

  /**
   * 商品页面地址 比较(eq)
   */
  private String itemPageUrlEq;
  /**
   * 商品页面地址 比较(neq)
   */
  private String itemPageUrlNeq;
  /**
   * 商品页面地址 比较(gt)
   */
  private String itemPageUrlGt;
  /**
   * 商品页面地址 比较(gte)
   */
  private String itemPageUrlGte;
  /**
   * 商品页面地址 比较(lt)
   */
  private String itemPageUrlLt;
  /**
   * 商品页面地址 比较(lte)
   */
  private String itemPageUrlLte;
  /**
   * 商品页面地址 比较(contains)
   */
  private String itemPageUrlContains;
  /**
   * 商品页面地址 比较(notcontains)
   */
  private String itemPageUrlNotcontains;
  /**
   * 商品页面地址 比较(startswith)
   */
  private String itemPageUrlStartswith;
  /**
   * 商品页面地址 比较(endswith)
   */
  private String itemPageUrlEndswith;
  /**
   * 商品页面地址 比较(isnull)
   */
  private Boolean itemPageUrlIsnull;
  /**
   * 商品页面地址 比较(isnotnull)
   */
  private Boolean itemPageUrlIsnotnull;

  /**
   * 商品页面地址(精确搜索)
   */
  private List<String> itemPageUrlInList;

  /**
   * 主图地址(模糊搜索)
   */
  private String primaryImageUrl;

  /**
   * 主图地址 比较(eq)
   */
  private String primaryImageUrlEq;
  /**
   * 主图地址 比较(neq)
   */
  private String primaryImageUrlNeq;
  /**
   * 主图地址 比较(gt)
   */
  private String primaryImageUrlGt;
  /**
   * 主图地址 比较(gte)
   */
  private String primaryImageUrlGte;
  /**
   * 主图地址 比较(lt)
   */
  private String primaryImageUrlLt;
  /**
   * 主图地址 比较(lte)
   */
  private String primaryImageUrlLte;
  /**
   * 主图地址 比较(contains)
   */
  private String primaryImageUrlContains;
  /**
   * 主图地址 比较(notcontains)
   */
  private String primaryImageUrlNotcontains;
  /**
   * 主图地址 比较(startswith)
   */
  private String primaryImageUrlStartswith;
  /**
   * 主图地址 比较(endswith)
   */
  private String primaryImageUrlEndswith;
  /**
   * 主图地址 比较(isnull)
   */
  private Boolean primaryImageUrlIsnull;
  /**
   * 主图地址 比较(isnotnull)
   */
  private Boolean primaryImageUrlIsnotnull;

  /**
   * 主图地址(精确搜索)
   */
  private List<String> primaryImageUrlInList;

  /**
   * 货架名称(模糊搜索)
   */
  private String shelfName;

  /**
   * 货架名称 比较(eq)
   */
  private String shelfNameEq;
  /**
   * 货架名称 比较(neq)
   */
  private String shelfNameNeq;
  /**
   * 货架名称 比较(gt)
   */
  private String shelfNameGt;
  /**
   * 货架名称 比较(gte)
   */
  private String shelfNameGte;
  /**
   * 货架名称 比较(lt)
   */
  private String shelfNameLt;
  /**
   * 货架名称 比较(lte)
   */
  private String shelfNameLte;
  /**
   * 货架名称 比较(contains)
   */
  private String shelfNameContains;
  /**
   * 货架名称 比较(notcontains)
   */
  private String shelfNameNotcontains;
  /**
   * 货架名称 比较(startswith)
   */
  private String shelfNameStartswith;
  /**
   * 货架名称 比较(endswith)
   */
  private String shelfNameEndswith;
  /**
   * 货架名称 比较(isnull)
   */
  private Boolean shelfNameIsnull;
  /**
   * 货架名称 比较(isnotnull)
   */
  private Boolean shelfNameIsnotnull;

  /**
   * 货架名称(精确搜索)
   */
  private List<String> shelfNameInList;

  /**
   * 商品类别路径(模糊搜索)
   */
  private String primaryCategoryPath;

  /**
   * 商品类别路径 比较(eq)
   */
  private String primaryCategoryPathEq;
  /**
   * 商品类别路径 比较(neq)
   */
  private String primaryCategoryPathNeq;
  /**
   * 商品类别路径 比较(gt)
   */
  private String primaryCategoryPathGt;
  /**
   * 商品类别路径 比较(gte)
   */
  private String primaryCategoryPathGte;
  /**
   * 商品类别路径 比较(lt)
   */
  private String primaryCategoryPathLt;
  /**
   * 商品类别路径 比较(lte)
   */
  private String primaryCategoryPathLte;
  /**
   * 商品类别路径 比较(contains)
   */
  private String primaryCategoryPathContains;
  /**
   * 商品类别路径 比较(notcontains)
   */
  private String primaryCategoryPathNotcontains;
  /**
   * 商品类别路径 比较(startswith)
   */
  private String primaryCategoryPathStartswith;
  /**
   * 商品类别路径 比较(endswith)
   */
  private String primaryCategoryPathEndswith;
  /**
   * 商品类别路径 比较(isnull)
   */
  private Boolean primaryCategoryPathIsnull;
  /**
   * 商品类别路径 比较(isnotnull)
   */
  private Boolean primaryCategoryPathIsnotnull;

  /**
   * 商品类别路径(精确搜索)
   */
  private List<String> primaryCategoryPathInList;

  /**
   * 品牌(模糊搜索)
   */
  private String brand;

  /**
   * 品牌 比较(eq)
   */
  private String brandEq;
  /**
   * 品牌 比较(neq)
   */
  private String brandNeq;
  /**
   * 品牌 比较(gt)
   */
  private String brandGt;
  /**
   * 品牌 比较(gte)
   */
  private String brandGte;
  /**
   * 品牌 比较(lt)
   */
  private String brandLt;
  /**
   * 品牌 比较(lte)
   */
  private String brandLte;
  /**
   * 品牌 比较(contains)
   */
  private String brandContains;
  /**
   * 品牌 比较(notcontains)
   */
  private String brandNotcontains;
  /**
   * 品牌 比较(startswith)
   */
  private String brandStartswith;
  /**
   * 品牌 比较(endswith)
   */
  private String brandEndswith;
  /**
   * 品牌 比较(isnull)
   */
  private Boolean brandIsnull;
  /**
   * 品牌 比较(isnotnull)
   */
  private Boolean brandIsnotnull;

  /**
   * 品牌(精确搜索)
   */
  private List<String> brandInList;

  /**
   * 最早销售开始日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date offerStartDateStart;

  /**
   * 最晚销售开始日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date offerStartDateEnd;

  /**
   * 销售开始日期 比较(eq)
   */
  private Date offerStartDateEq;
  /**
   * 销售开始日期 比较(neq)
   */
  private Date offerStartDateNeq;
  /**
   * 销售开始日期 比较(gt)
   */
  private Date offerStartDateGt;
  /**
   * 销售开始日期 比较(gte)
   */
  private Date offerStartDateGte;
  /**
   * 销售开始日期 比较(lt)
   */
  private Date offerStartDateLt;
  /**
   * 销售开始日期 比较(lte)
   */
  private Date offerStartDateLte;
  /**
   * 销售开始日期 比较(contains)
   */
  private Date offerStartDateContains;
  /**
   * 销售开始日期 比较(notcontains)
   */
  private Date offerStartDateNotcontains;
  /**
   * 销售开始日期 比较(startswith)
   */
  private Date offerStartDateStartswith;
  /**
   * 销售开始日期 比较(endswith)
   */
  private Date offerStartDateEndswith;
  /**
   * 销售开始日期 比较(isnull)
   */
  private Boolean offerStartDateIsnull;
  /**
   * 销售开始日期 比较(isnotnull)
   */
  private Boolean offerStartDateIsnotnull;

  /**
   * 最早销售结束日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date offerEndDateStart;

  /**
   * 最晚销售结束日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date offerEndDateEnd;

  /**
   * 销售结束日期 比较(eq)
   */
  private Date offerEndDateEq;
  /**
   * 销售结束日期 比较(neq)
   */
  private Date offerEndDateNeq;
  /**
   * 销售结束日期 比较(gt)
   */
  private Date offerEndDateGt;
  /**
   * 销售结束日期 比较(gte)
   */
  private Date offerEndDateGte;
  /**
   * 销售结束日期 比较(lt)
   */
  private Date offerEndDateLt;
  /**
   * 销售结束日期 比较(lte)
   */
  private Date offerEndDateLte;
  /**
   * 销售结束日期 比较(contains)
   */
  private Date offerEndDateContains;
  /**
   * 销售结束日期 比较(notcontains)
   */
  private Date offerEndDateNotcontains;
  /**
   * 销售结束日期 比较(startswith)
   */
  private Date offerEndDateStartswith;
  /**
   * 销售结束日期 比较(endswith)
   */
  private Date offerEndDateEndswith;
  /**
   * 销售结束日期 比较(isnull)
   */
  private Boolean offerEndDateIsnull;
  /**
   * 销售结束日期 比较(isnotnull)
   */
  private Boolean offerEndDateIsnotnull;

  /**
   * 最早商品创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date itemCreationDateStart;

  /**
   * 最晚商品创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date itemCreationDateEnd;

  /**
   * 商品创建时间 比较(eq)
   */
  private Date itemCreationDateEq;
  /**
   * 商品创建时间 比较(neq)
   */
  private Date itemCreationDateNeq;
  /**
   * 商品创建时间 比较(gt)
   */
  private Date itemCreationDateGt;
  /**
   * 商品创建时间 比较(gte)
   */
  private Date itemCreationDateGte;
  /**
   * 商品创建时间 比较(lt)
   */
  private Date itemCreationDateLt;
  /**
   * 商品创建时间 比较(lte)
   */
  private Date itemCreationDateLte;
  /**
   * 商品创建时间 比较(contains)
   */
  private Date itemCreationDateContains;
  /**
   * 商品创建时间 比较(notcontains)
   */
  private Date itemCreationDateNotcontains;
  /**
   * 商品创建时间 比较(startswith)
   */
  private Date itemCreationDateStartswith;
  /**
   * 商品创建时间 比较(endswith)
   */
  private Date itemCreationDateEndswith;
  /**
   * 商品创建时间 比较(isnull)
   */
  private Boolean itemCreationDateIsnull;
  /**
   * 商品创建时间 比较(isnotnull)
   */
  private Boolean itemCreationDateIsnotnull;

  /**
   * 最早商品更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date itemLastUpdatedStart;

  /**
   * 最晚商品更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date itemLastUpdatedEnd;

  /**
   * 商品更新时间 比较(eq)
   */
  private Date itemLastUpdatedEq;
  /**
   * 商品更新时间 比较(neq)
   */
  private Date itemLastUpdatedNeq;
  /**
   * 商品更新时间 比较(gt)
   */
  private Date itemLastUpdatedGt;
  /**
   * 商品更新时间 比较(gte)
   */
  private Date itemLastUpdatedGte;
  /**
   * 商品更新时间 比较(lt)
   */
  private Date itemLastUpdatedLt;
  /**
   * 商品更新时间 比较(lte)
   */
  private Date itemLastUpdatedLte;
  /**
   * 商品更新时间 比较(contains)
   */
  private Date itemLastUpdatedContains;
  /**
   * 商品更新时间 比较(notcontains)
   */
  private Date itemLastUpdatedNotcontains;
  /**
   * 商品更新时间 比较(startswith)
   */
  private Date itemLastUpdatedStartswith;
  /**
   * 商品更新时间 比较(endswith)
   */
  private Date itemLastUpdatedEndswith;
  /**
   * 商品更新时间 比较(isnull)
   */
  private Boolean itemLastUpdatedIsnull;
  /**
   * 商品更新时间 比较(isnotnull)
   */
  private Boolean itemLastUpdatedIsnotnull;

  /**
   * 评论数
   */
  private Integer reviewsCount;

  /**
   * 最小评论数
   */
  private Integer reviewsCountMin;

  /**
   * 最大评论数
   */
  private Integer reviewsCountMax;

  /**
   * 评论数 比较(eq)
   */
  private Integer reviewsCountEq;
  /**
   * 评论数 比较(neq)
   */
  private Integer reviewsCountNeq;
  /**
   * 评论数 比较(gt)
   */
  private Integer reviewsCountGt;
  /**
   * 评论数 比较(gte)
   */
  private Integer reviewsCountGte;
  /**
   * 评论数 比较(lt)
   */
  private Integer reviewsCountLt;
  /**
   * 评论数 比较(lte)
   */
  private Integer reviewsCountLte;
  /**
   * 评论数 比较(contains)
   */
  private Integer reviewsCountContains;
  /**
   * 评论数 比较(notcontains)
   */
  private Integer reviewsCountNotcontains;
  /**
   * 评论数 比较(startswith)
   */
  private Integer reviewsCountStartswith;
  /**
   * 评论数 比较(endswith)
   */
  private Integer reviewsCountEndswith;
  /**
   * 评论数 比较(isnull)
   */
  private Boolean reviewsCountIsnull;
  /**
   * 评论数 比较(isnotnull)
   */
  private Boolean reviewsCountIsnotnull;

  /**
   * 评分(模糊搜索)
   */
  private String averageRating;

  /**
   * 评分 比较(eq)
   */
  private String averageRatingEq;
  /**
   * 评分 比较(neq)
   */
  private String averageRatingNeq;
  /**
   * 评分 比较(gt)
   */
  private String averageRatingGt;
  /**
   * 评分 比较(gte)
   */
  private String averageRatingGte;
  /**
   * 评分 比较(lt)
   */
  private String averageRatingLt;
  /**
   * 评分 比较(lte)
   */
  private String averageRatingLte;
  /**
   * 评分 比较(contains)
   */
  private String averageRatingContains;
  /**
   * 评分 比较(notcontains)
   */
  private String averageRatingNotcontains;
  /**
   * 评分 比较(startswith)
   */
  private String averageRatingStartswith;
  /**
   * 评分 比较(endswith)
   */
  private String averageRatingEndswith;
  /**
   * 评分 比较(isnull)
   */
  private Boolean averageRatingIsnull;
  /**
   * 评分 比较(isnotnull)
   */
  private Boolean averageRatingIsnotnull;

  /**
   * 评分(精确搜索)
   */
  private List<String> averageRatingInList;

  /**
   * 可搜索(模糊搜索)
   */
  private String searchable;

  /**
   * 可搜索 比较(eq)
   */
  private String searchableEq;
  /**
   * 可搜索 比较(neq)
   */
  private String searchableNeq;
  /**
   * 可搜索 比较(gt)
   */
  private String searchableGt;
  /**
   * 可搜索 比较(gte)
   */
  private String searchableGte;
  /**
   * 可搜索 比较(lt)
   */
  private String searchableLt;
  /**
   * 可搜索 比较(lte)
   */
  private String searchableLte;
  /**
   * 可搜索 比较(contains)
   */
  private String searchableContains;
  /**
   * 可搜索 比较(notcontains)
   */
  private String searchableNotcontains;
  /**
   * 可搜索 比较(startswith)
   */
  private String searchableStartswith;
  /**
   * 可搜索 比较(endswith)
   */
  private String searchableEndswith;
  /**
   * 可搜索 比较(isnull)
   */
  private Boolean searchableIsnull;
  /**
   * 可搜索 比较(isnotnull)
   */
  private Boolean searchableIsnotnull;

  /**
   * 可搜索(精确搜索)
   */
  private List<String> searchableInList;

  /**
   * 变体组ID(模糊搜索)
   */
  private String variantGroupId;

  /**
   * 变体组ID 比较(eq)
   */
  private String variantGroupIdEq;
  /**
   * 变体组ID 比较(neq)
   */
  private String variantGroupIdNeq;
  /**
   * 变体组ID 比较(gt)
   */
  private String variantGroupIdGt;
  /**
   * 变体组ID 比较(gte)
   */
  private String variantGroupIdGte;
  /**
   * 变体组ID 比较(lt)
   */
  private String variantGroupIdLt;
  /**
   * 变体组ID 比较(lte)
   */
  private String variantGroupIdLte;
  /**
   * 变体组ID 比较(contains)
   */
  private String variantGroupIdContains;
  /**
   * 变体组ID 比较(notcontains)
   */
  private String variantGroupIdNotcontains;
  /**
   * 变体组ID 比较(startswith)
   */
  private String variantGroupIdStartswith;
  /**
   * 变体组ID 比较(endswith)
   */
  private String variantGroupIdEndswith;
  /**
   * 变体组ID 比较(isnull)
   */
  private Boolean variantGroupIdIsnull;
  /**
   * 变体组ID 比较(isnotnull)
   */
  private Boolean variantGroupIdIsnotnull;

  /**
   * 变体组ID(精确搜索)
   */
  private List<String> variantGroupIdInList;

  /**
   * 是否主变体(模糊搜索)
   */
  private String primaryVariant;

  /**
   * 是否主变体 比较(eq)
   */
  private String primaryVariantEq;
  /**
   * 是否主变体 比较(neq)
   */
  private String primaryVariantNeq;
  /**
   * 是否主变体 比较(gt)
   */
  private String primaryVariantGt;
  /**
   * 是否主变体 比较(gte)
   */
  private String primaryVariantGte;
  /**
   * 是否主变体 比较(lt)
   */
  private String primaryVariantLt;
  /**
   * 是否主变体 比较(lte)
   */
  private String primaryVariantLte;
  /**
   * 是否主变体 比较(contains)
   */
  private String primaryVariantContains;
  /**
   * 是否主变体 比较(notcontains)
   */
  private String primaryVariantNotcontains;
  /**
   * 是否主变体 比较(startswith)
   */
  private String primaryVariantStartswith;
  /**
   * 是否主变体 比较(endswith)
   */
  private String primaryVariantEndswith;
  /**
   * 是否主变体 比较(isnull)
   */
  private Boolean primaryVariantIsnull;
  /**
   * 是否主变体 比较(isnotnull)
   */
  private Boolean primaryVariantIsnotnull;

  /**
   * 是否主变体(精确搜索)
   */
  private List<String> primaryVariantInList;

  /**
   * 变体组属性(模糊搜索)
   */
  private String variantGroupingAttributes;

  /**
   * 变体组属性 比较(eq)
   */
  private String variantGroupingAttributesEq;
  /**
   * 变体组属性 比较(neq)
   */
  private String variantGroupingAttributesNeq;
  /**
   * 变体组属性 比较(gt)
   */
  private String variantGroupingAttributesGt;
  /**
   * 变体组属性 比较(gte)
   */
  private String variantGroupingAttributesGte;
  /**
   * 变体组属性 比较(lt)
   */
  private String variantGroupingAttributesLt;
  /**
   * 变体组属性 比较(lte)
   */
  private String variantGroupingAttributesLte;
  /**
   * 变体组属性 比较(contains)
   */
  private String variantGroupingAttributesContains;
  /**
   * 变体组属性 比较(notcontains)
   */
  private String variantGroupingAttributesNotcontains;
  /**
   * 变体组属性 比较(startswith)
   */
  private String variantGroupingAttributesStartswith;
  /**
   * 变体组属性 比较(endswith)
   */
  private String variantGroupingAttributesEndswith;
  /**
   * 变体组属性 比较(isnull)
   */
  private Boolean variantGroupingAttributesIsnull;
  /**
   * 变体组属性 比较(isnotnull)
   */
  private Boolean variantGroupingAttributesIsnotnull;

  /**
   * 变体组属性(精确搜索)
   */
  private List<String> variantGroupingAttributesInList;

  /**
   * 变体属性值(模糊搜索)
   */
  private String variantGroupingValues;

  /**
   * 变体属性值 比较(eq)
   */
  private String variantGroupingValuesEq;
  /**
   * 变体属性值 比较(neq)
   */
  private String variantGroupingValuesNeq;
  /**
   * 变体属性值 比较(gt)
   */
  private String variantGroupingValuesGt;
  /**
   * 变体属性值 比较(gte)
   */
  private String variantGroupingValuesGte;
  /**
   * 变体属性值 比较(lt)
   */
  private String variantGroupingValuesLt;
  /**
   * 变体属性值 比较(lte)
   */
  private String variantGroupingValuesLte;
  /**
   * 变体属性值 比较(contains)
   */
  private String variantGroupingValuesContains;
  /**
   * 变体属性值 比较(notcontains)
   */
  private String variantGroupingValuesNotcontains;
  /**
   * 变体属性值 比较(startswith)
   */
  private String variantGroupingValuesStartswith;
  /**
   * 变体属性值 比较(endswith)
   */
  private String variantGroupingValuesEndswith;
  /**
   * 变体属性值 比较(isnull)
   */
  private Boolean variantGroupingValuesIsnull;
  /**
   * 变体属性值 比较(isnotnull)
   */
  private Boolean variantGroupingValuesIsnotnull;

  /**
   * 变体属性值(精确搜索)
   */
  private List<String> variantGroupingValuesInList;

  /**
   * 竞争商品网站(模糊搜索)
   */
  private String competitorUrl;

  /**
   * 竞争商品网站 比较(eq)
   */
  private String competitorUrlEq;
  /**
   * 竞争商品网站 比较(neq)
   */
  private String competitorUrlNeq;
  /**
   * 竞争商品网站 比较(gt)
   */
  private String competitorUrlGt;
  /**
   * 竞争商品网站 比较(gte)
   */
  private String competitorUrlGte;
  /**
   * 竞争商品网站 比较(lt)
   */
  private String competitorUrlLt;
  /**
   * 竞争商品网站 比较(lte)
   */
  private String competitorUrlLte;
  /**
   * 竞争商品网站 比较(contains)
   */
  private String competitorUrlContains;
  /**
   * 竞争商品网站 比较(notcontains)
   */
  private String competitorUrlNotcontains;
  /**
   * 竞争商品网站 比较(startswith)
   */
  private String competitorUrlStartswith;
  /**
   * 竞争商品网站 比较(endswith)
   */
  private String competitorUrlEndswith;
  /**
   * 竞争商品网站 比较(isnull)
   */
  private Boolean competitorUrlIsnull;
  /**
   * 竞争商品网站 比较(isnotnull)
   */
  private Boolean competitorUrlIsnotnull;

  /**
   * 竞争商品网站(精确搜索)
   */
  private List<String> competitorUrlInList;

  /**
   * 竞争商品价格
   */
  private java.math.BigDecimal competitorPrice;

  /**
   * 最小竞争商品价格
   */
  private java.math.BigDecimal competitorPriceMin;

  /**
   * 最大竞争商品价格
   */
  private java.math.BigDecimal competitorPriceMax;

  /**
   * 竞争商品价格 比较(eq)
   */
  private java.math.BigDecimal competitorPriceEq;
  /**
   * 竞争商品价格 比较(neq)
   */
  private java.math.BigDecimal competitorPriceNeq;
  /**
   * 竞争商品价格 比较(gt)
   */
  private java.math.BigDecimal competitorPriceGt;
  /**
   * 竞争商品价格 比较(gte)
   */
  private java.math.BigDecimal competitorPriceGte;
  /**
   * 竞争商品价格 比较(lt)
   */
  private java.math.BigDecimal competitorPriceLt;
  /**
   * 竞争商品价格 比较(lte)
   */
  private java.math.BigDecimal competitorPriceLte;
  /**
   * 竞争商品价格 比较(contains)
   */
  private java.math.BigDecimal competitorPriceContains;
  /**
   * 竞争商品价格 比较(notcontains)
   */
  private java.math.BigDecimal competitorPriceNotcontains;
  /**
   * 竞争商品价格 比较(startswith)
   */
  private java.math.BigDecimal competitorPriceStartswith;
  /**
   * 竞争商品价格 比较(endswith)
   */
  private java.math.BigDecimal competitorPriceEndswith;
  /**
   * 竞争商品价格 比较(isnull)
   */
  private Boolean competitorPriceIsnull;
  /**
   * 竞争商品价格 比较(isnotnull)
   */
  private Boolean competitorPriceIsnotnull;

  /**
   * 竞争商品运费
   */
  private java.math.BigDecimal competitorShipPrice;

  /**
   * 最小竞争商品运费
   */
  private java.math.BigDecimal competitorShipPriceMin;

  /**
   * 最大竞争商品运费
   */
  private java.math.BigDecimal competitorShipPriceMax;

  /**
   * 竞争商品运费 比较(eq)
   */
  private java.math.BigDecimal competitorShipPriceEq;
  /**
   * 竞争商品运费 比较(neq)
   */
  private java.math.BigDecimal competitorShipPriceNeq;
  /**
   * 竞争商品运费 比较(gt)
   */
  private java.math.BigDecimal competitorShipPriceGt;
  /**
   * 竞争商品运费 比较(gte)
   */
  private java.math.BigDecimal competitorShipPriceGte;
  /**
   * 竞争商品运费 比较(lt)
   */
  private java.math.BigDecimal competitorShipPriceLt;
  /**
   * 竞争商品运费 比较(lte)
   */
  private java.math.BigDecimal competitorShipPriceLte;
  /**
   * 竞争商品运费 比较(contains)
   */
  private java.math.BigDecimal competitorShipPriceContains;
  /**
   * 竞争商品运费 比较(notcontains)
   */
  private java.math.BigDecimal competitorShipPriceNotcontains;
  /**
   * 竞争商品运费 比较(startswith)
   */
  private java.math.BigDecimal competitorShipPriceStartswith;
  /**
   * 竞争商品运费 比较(endswith)
   */
  private java.math.BigDecimal competitorShipPriceEndswith;
  /**
   * 竞争商品运费 比较(isnull)
   */
  private Boolean competitorShipPriceIsnull;
  /**
   * 竞争商品运费 比较(isnotnull)
   */
  private Boolean competitorShipPriceIsnotnull;

  /**
   * 最早竞争信息更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date competitorLastDateFetchedStart;

  /**
   * 最晚竞争信息更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date competitorLastDateFetchedEnd;

  /**
   * 竞争信息更新时间 比较(eq)
   */
  private Date competitorLastDateFetchedEq;
  /**
   * 竞争信息更新时间 比较(neq)
   */
  private Date competitorLastDateFetchedNeq;
  /**
   * 竞争信息更新时间 比较(gt)
   */
  private Date competitorLastDateFetchedGt;
  /**
   * 竞争信息更新时间 比较(gte)
   */
  private Date competitorLastDateFetchedGte;
  /**
   * 竞争信息更新时间 比较(lt)
   */
  private Date competitorLastDateFetchedLt;
  /**
   * 竞争信息更新时间 比较(lte)
   */
  private Date competitorLastDateFetchedLte;
  /**
   * 竞争信息更新时间 比较(contains)
   */
  private Date competitorLastDateFetchedContains;
  /**
   * 竞争信息更新时间 比较(notcontains)
   */
  private Date competitorLastDateFetchedNotcontains;
  /**
   * 竞争信息更新时间 比较(startswith)
   */
  private Date competitorLastDateFetchedStartswith;
  /**
   * 竞争信息更新时间 比较(endswith)
   */
  private Date competitorLastDateFetchedEndswith;
  /**
   * 竞争信息更新时间 比较(isnull)
   */
  private Boolean competitorLastDateFetchedIsnull;
  /**
   * 竞争信息更新时间 比较(isnotnull)
   */
  private Boolean competitorLastDateFetchedIsnotnull;

  /**
   * 定价策略(模糊搜索)
   */
  private String repricerStrategy;

  /**
   * 定价策略 比较(eq)
   */
  private String repricerStrategyEq;
  /**
   * 定价策略 比较(neq)
   */
  private String repricerStrategyNeq;
  /**
   * 定价策略 比较(gt)
   */
  private String repricerStrategyGt;
  /**
   * 定价策略 比较(gte)
   */
  private String repricerStrategyGte;
  /**
   * 定价策略 比较(lt)
   */
  private String repricerStrategyLt;
  /**
   * 定价策略 比较(lte)
   */
  private String repricerStrategyLte;
  /**
   * 定价策略 比较(contains)
   */
  private String repricerStrategyContains;
  /**
   * 定价策略 比较(notcontains)
   */
  private String repricerStrategyNotcontains;
  /**
   * 定价策略 比较(startswith)
   */
  private String repricerStrategyStartswith;
  /**
   * 定价策略 比较(endswith)
   */
  private String repricerStrategyEndswith;
  /**
   * 定价策略 比较(isnull)
   */
  private Boolean repricerStrategyIsnull;
  /**
   * 定价策略 比较(isnotnull)
   */
  private Boolean repricerStrategyIsnotnull;

  /**
   * 定价策略(精确搜索)
   */
  private List<String> repricerStrategyInList;

  /**
   * 卖方最低限价
   */
  private java.math.BigDecimal minimumSellerAllowedPrice;

  /**
   * 最小卖方最低限价
   */
  private java.math.BigDecimal minimumSellerAllowedPriceMin;

  /**
   * 最大卖方最低限价
   */
  private java.math.BigDecimal minimumSellerAllowedPriceMax;

  /**
   * 卖方最低限价 比较(eq)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceEq;
  /**
   * 卖方最低限价 比较(neq)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceNeq;
  /**
   * 卖方最低限价 比较(gt)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceGt;
  /**
   * 卖方最低限价 比较(gte)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceGte;
  /**
   * 卖方最低限价 比较(lt)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceLt;
  /**
   * 卖方最低限价 比较(lte)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceLte;
  /**
   * 卖方最低限价 比较(contains)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceContains;
  /**
   * 卖方最低限价 比较(notcontains)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceNotcontains;
  /**
   * 卖方最低限价 比较(startswith)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceStartswith;
  /**
   * 卖方最低限价 比较(endswith)
   */
  private java.math.BigDecimal minimumSellerAllowedPriceEndswith;
  /**
   * 卖方最低限价 比较(isnull)
   */
  private Boolean minimumSellerAllowedPriceIsnull;
  /**
   * 卖方最低限价 比较(isnotnull)
   */
  private Boolean minimumSellerAllowedPriceIsnotnull;

  /**
   * 卖方最高限价
   */
  private java.math.BigDecimal maximumSellerAllowedPrice;

  /**
   * 最小卖方最高限价
   */
  private java.math.BigDecimal maximumSellerAllowedPriceMin;

  /**
   * 最大卖方最高限价
   */
  private java.math.BigDecimal maximumSellerAllowedPriceMax;

  /**
   * 卖方最高限价 比较(eq)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceEq;
  /**
   * 卖方最高限价 比较(neq)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceNeq;
  /**
   * 卖方最高限价 比较(gt)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceGt;
  /**
   * 卖方最高限价 比较(gte)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceGte;
  /**
   * 卖方最高限价 比较(lt)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceLt;
  /**
   * 卖方最高限价 比较(lte)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceLte;
  /**
   * 卖方最高限价 比较(contains)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceContains;
  /**
   * 卖方最高限价 比较(notcontains)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceNotcontains;
  /**
   * 卖方最高限价 比较(startswith)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceStartswith;
  /**
   * 卖方最高限价 比较(endswith)
   */
  private java.math.BigDecimal maximumSellerAllowedPriceEndswith;
  /**
   * 卖方最高限价 比较(isnull)
   */
  private Boolean maximumSellerAllowedPriceIsnull;
  /**
   * 卖方最高限价 比较(isnotnull)
   */
  private Boolean maximumSellerAllowedPriceIsnotnull;

  /**
   * 重新定价状态(模糊搜索)
   */
  private String repricerStatus;

  /**
   * 重新定价状态 比较(eq)
   */
  private String repricerStatusEq;
  /**
   * 重新定价状态 比较(neq)
   */
  private String repricerStatusNeq;
  /**
   * 重新定价状态 比较(gt)
   */
  private String repricerStatusGt;
  /**
   * 重新定价状态 比较(gte)
   */
  private String repricerStatusGte;
  /**
   * 重新定价状态 比较(lt)
   */
  private String repricerStatusLt;
  /**
   * 重新定价状态 比较(lte)
   */
  private String repricerStatusLte;
  /**
   * 重新定价状态 比较(contains)
   */
  private String repricerStatusContains;
  /**
   * 重新定价状态 比较(notcontains)
   */
  private String repricerStatusNotcontains;
  /**
   * 重新定价状态 比较(startswith)
   */
  private String repricerStatusStartswith;
  /**
   * 重新定价状态 比较(endswith)
   */
  private String repricerStatusEndswith;
  /**
   * 重新定价状态 比较(isnull)
   */
  private Boolean repricerStatusIsnull;
  /**
   * 重新定价状态 比较(isnotnull)
   */
  private Boolean repricerStatusIsnotnull;

  /**
   * 重新定价状态(精确搜索)
   */
  private List<String> repricerStatusInList;

  /**
   * 是否有 图片
   */
  private Boolean image;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
